#include "linked_stack/linked_stack.h"
#include "seq_queue/seq_queue.h"
#include <limits.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>  // 添加memset头文件
#define ll long long

Stack *hour_st, *_5_min_st, *_1_min_st;
ll count = 0;
Queue *clock_qu = NULL;

// 修复队列初始化函数
void initialize_queue() {
    // 使用固定数组避免临时变量问题
    int balls[27];
    for (int i = 0; i < 27; i++) {
        balls[i] = i + 1;
        queue_push(clock_qu, &balls[i]);
    }
}

// 改进的检查队列是否有序的函数
int is_queue_sorted(Queue *q) {
    if (queue_empty(q)) return 0;
    
    int sorted = 1;
    int ball_array[30];
    int index = 0;
    int temp;
    
    // 临时出队所有球到数组
    while (!queue_empty(q)) {
        if (queue_front(q) == NULL) {  // 安全检查
            printf("错误: queue_front返回NULL\n");
            return 0;
        }
        int ball = *(int*)queue_front(q);
        queue_pop(q);
        ball_array[index++] = ball;
        if (index >= 30) break;  // 防止数组越界
    }
    
    // 检查是否有序 (1,2,3,...,27)
    for (int i = 1; i < index; i++) {
        if (ball_array[i] != ball_array[i-1] + 1) {
            sorted = 0;
            break;
        }
    }
    
    // 重新入队
    for (int i = 0; i < index; i++) {
        queue_push(q, &ball_array[i]);
    }
    
    return sorted && (index == 27);
}

int main(int argc, char *argv[]) {
    // 初始化数据结构
    if (queue_init(&clock_qu, sizeof(int), 30) != 0) {
        printf("队列初始化失败\n");
        return -1;
    }
    if (stack_init(&hour_st, sizeof(int)) != 1 || 
        stack_init(&_5_min_st, sizeof(int)) != 1 || 
        stack_init(&_1_min_st, sizeof(int)) != 1) {
        printf("栈初始化失败\n");
        return -1;
    }

    // 初始化队列：1,2,3,...,27
    initialize_queue();
    printf("初始化完成，队列大小: %d\n", queue_nmemb(clock_qu));

    int should_check_order = 0;  // 控制何时检查顺序

    while (1) {
        count++;
        
        // 安全检查：队列是否为空
        if (queue_empty(clock_qu)) {
            printf("错误：队列为空 at count %lld\n", count);
            break;
        }
        
        // 安全检查：queue_front返回值
        if (queue_front(clock_qu) == NULL) {
            printf("错误：queue_front返回NULL at count %lld\n", count);
            break;
        }
        
        int cur_ball = *(int*)queue_front(clock_qu);
        queue_pop(clock_qu);
        
        // 修复：使用正确的栈容量[2,4](@ref)
        // 1. 尝试放入1分钟栈（容量4）
        if (stack_nmemb(_1_min_st) < 4) {
            stack_push(_1_min_st, &cur_ball);
            should_check_order = 0;  // 栈未清空，不检查顺序
            continue;
        }
        
        // 2. 1分钟栈已满，清空1分钟栈
        while (!stack_empty(_1_min_st)) {
            int ball = *(int*)stack_top(_1_min_st);
            queue_push(clock_qu, &ball);
            stack_pop(_1_min_st);
        }
        
        // 3. 尝试放入5分钟栈（容量11）
        if (stack_nmemb(_5_min_st) < 11) {
            stack_push(_5_min_st, &cur_ball);
            should_check_order = 0;
            continue;
        }
        
        // 4. 5分钟栈已满，清空5分钟栈
        while (!stack_empty(_5_min_st)) {
            int ball = *(int*)stack_top(_5_min_st);
            queue_push(clock_qu, &ball);
            stack_pop(_5_min_st);
        }
        
        // 5. 尝试放入小时栈（容量11）
        if (stack_nmemb(hour_st) < 11) {
            stack_push(hour_st, &cur_ball);
            should_check_order = 0;
            continue;
        }

        // 6. 小时栈已满，清空所有栈[1](@ref)
        while (!stack_empty(hour_st)) {
            int ball = *(int*)stack_top(hour_st);
            queue_push(clock_qu, &ball);
            stack_pop(hour_st);
        }
        
        // 当前球也放回队列
        queue_push(clock_qu, &cur_ball);
        should_check_order = 1;  // 所有栈都清空，可以检查顺序

        // 只有在完整循环后才检查顺序[1](@ref)
        if (should_check_order && is_queue_sorted(clock_qu)) {
            printf("找到有序序列！\n");
            break;
        }
        
        // 调试输出
        if (count % 1000000 == 0) {
            printf("进度: %lld 次循环, 队列大小: %d\n", count, queue_nmemb(clock_qu));
        }
        
        // 安全机制
        if (count > 100000000) {
            printf("安全机制触发，当前计数: %lld\n", count);
            printf("队列大小: %d, 栈大小: 1min=%d, 5min=%d, hour=%d\n", 
                   queue_nmemb(clock_qu), stack_nmemb(_1_min_st), 
                   stack_nmemb(_5_min_st), stack_nmemb(hour_st));
            break;
        }
    }

    printf("总周期数: %lld\n", count);
    printf("相当于 %lld 天 %lld 小时 %lld 分钟\n", 
           count/(24 * 60), (count/60)%24, count%60);
    
    // 清理资源
    queue_destroy(clock_qu);
    stack_destory(hour_st);
    stack_destory(_5_min_st);
    stack_destory(_1_min_st);
    
    return 0;
}